M

MLOG

Türkçe

TypeScript ayrıştırılmış birleşimlerini keşfedin, sağlam ve tür güvenli durum makineleri oluşturmak için güçlü bir araç. Durumları nasıl tanımlayacağınızı, geçişleri nasıl yöneteceğinizi ve artan kod güvenilirliği için TypeScript'in tür sisteminden nasıl yararlanacağınızı öğrenin.

TypeScript Ayrıştırılmış Birleşimler: Tür Güvenli Durum Makineleri Oluşturma

Yazılım geliştirme alanında, uygulama durumunu etkili bir şekilde yönetmek çok önemlidir. Durum makineleri, karmaşık durumlu sistemleri modellemek için güçlü bir soyutlama sağlar, öngörülebilir davranışı sağlar ve sistemin mantığı hakkındaki muhakemeyi basitleştirir. TypeScript, sağlam tür sistemiyle, ayrıştırılmış birleşimleri (etiketli birleşimler veya cebirsel veri türleri olarak da bilinir) kullanarak tür güvenli durum makineleri oluşturmak için harika bir mekanizma sunar.

Ayrıştırılmış Birleşimler Nedir?

Ayrıştırılmış birleşim, birkaç farklı türden biri olabilen bir değeri temsil eden bir türdür. Birliğin üyeleri olarak bilinen bu türlerin her biri, ayırt edici veya etiket olarak adlandırılan ortak, farklı bir özelliği paylaşır. Bu ayırt edici, TypeScript'in birliğin hangi üyesinin şu anda aktif olduğunu kesin olarak belirlemesini sağlayarak güçlü tür denetimi ve otomatik tamamlama sağlar.

Bunu bir trafik ışığı gibi düşünün. Üç durumdan birinde olabilir: Kırmızı, Sarı veya Yeşil. 'Renk' özelliği, ışığın tam olarak hangi durumda olduğunu bize bildiren ayırt edici görevi görür.

Durum Makineleri için Neden Ayrıştırılmış Birleşimler Kullanılır?

Ayrıştırılmış birleşimler, TypeScript'te durum makineleri oluştururken çeşitli önemli faydalar sağlar:

Ayrıştırılmış Birleşimlerle Durum Makinesi Tanımlama

Ayrıştırılmış birleşimleri kullanarak bir durum makinesini nasıl tanımlayacağımızı pratik bir örnekle gösterelim: bir sipariş işleme sistemi. Bir sipariş aşağıdaki durumlarda olabilir: Beklemede, İşleniyor, Gönderildi ve Teslim Edildi.

Adım 1: Durum Türlerini Tanımlayın

İlk olarak, her durum için ayrı ayrı türleri tanımlarız. Her tür, ayırt edici görevi gören bir `type` özelliğine ve ayrıca duruma özgü verilere sahip olacaktır.


interface Pending {
  type: "pending";
  orderId: string;
  customerName: string;
  items: string[];
}

interface Processing {
  type: "processing";
  orderId: string;
  assignedAgent: string;
}

interface Shipped {
  type: "shipped";
  orderId: string;
  trackingNumber: string;
}

interface Delivered {
  type: "delivered";
  orderId: string;
  deliveryDate: Date;
}

Adım 2: Ayrıştırılmış Birleşim Türünü Oluşturun

Ardından, `|` (birleşim) operatörünü kullanarak bu ayrı türleri birleştirerek ayrıştırılmış birleşimi oluştururuz.


type OrderState = Pending | Processing | Shipped | Delivered;

Şimdi, `OrderState`, `Pending`, `Processing`, `Shipped` veya `Delivered` olabilen bir değeri temsil eder. Her durumdaki `type` özelliği, ayırt edici görevi görerek TypeScript'in bunlar arasında ayrım yapmasını sağlar.

Durum Geçişlerini Yönetme

Durum makinemizi tanımladığımıza göre, durumlar arasında geçiş yapmak için bir mekanizmaya ihtiyacımız var. Mevcut durumu ve bir eylemi girdi olarak alan ve yeni durumu döndüren bir `processOrder` fonksiyonu oluşturalım.


interface Action {
  type: string;
  payload?: any;
}

function processOrder(state: OrderState, action: Action): OrderState {
  switch (state.type) {
    case "pending":
      if (action.type === "startProcessing") {
        return {
          type: "processing",
          orderId: state.orderId,
          assignedAgent: action.payload.agentId,
        };
      }
      return state; // Durum değişikliği yok

    case "processing":
      if (action.type === "shipOrder") {
        return {
          type: "shipped",
          orderId: state.orderId,
          trackingNumber: action.payload.trackingNumber,
        };
      }
      return state; // Durum değişikliği yok

    case "shipped":
      if (action.type === "deliverOrder") {
        return {
          type: "delivered",
          orderId: state.orderId,
          deliveryDate: new Date(),
        };
      }
      return state; // Durum değişikliği yok

    case "delivered":
      // Sipariş zaten teslim edildi, başka işlem yok
      return state;

    default:
      // Kapsamlılık kontrolü nedeniyle bu asla olmamalı
      return state; // Veya bir hata fırlat
  }
}

Açıklama

Kapsamlılık Kontrolünden Yararlanma

TypeScript'in kapsamlılık kontrolü, durum makinenizdeki tüm olası durumları ele aldığınızdan emin olmanızı sağlayan güçlü bir özelliktir. `OrderState` birliğine yeni bir durum eklerseniz, ancak `processOrder` fonksiyonunu güncellemeyi unutursanız, TypeScript bir hata işaretleyecektir.

Kapsamlılık kontrolünü etkinleştirmek için `never` türünü kullanabilirsiniz. Switch ifadesinin `default` durumu içinde, durumu `never` türünde bir değişkene atayın.


function processOrder(state: OrderState, action: Action): OrderState {
  switch (state.type) {
    // ... (önceki durumlar) ...

    default:
      const _exhaustiveCheck: never = state;
      return _exhaustiveCheck; // Veya bir hata fırlat
  }
}

`switch` ifadesi tüm olası `OrderState` değerlerini işlerse, `_exhaustiveCheck` değişkeni `never` türünde olacaktır ve kod derlenecektir. Ancak, `OrderState` birliğine yeni bir durum eklerseniz ve bunu `switch` ifadesinde işlemeyi unutursanız, `_exhaustiveCheck` değişkeni farklı bir türde olacaktır ve TypeScript, eksik durumu size bildirerek bir derleme zamanı hatası verecektir.

Pratik Örnekler ve Uygulamalar

Ayrıştırılmış birleşimler, basit sipariş işleme sistemlerinin ötesinde çok çeşitli senaryolarda uygulanabilir:

Örnek: UI Durum Yönetimi

Bir API'den veri getiren bir UI bileşeninin durumunu yönetme konusunda basit bir örnek düşünelim. Aşağıdaki durumları tanımlayabiliriz:


interface Initial {
  type: "initial";
}

interface Loading {
  type: "loading";
}

interface Success {
  type: "success";
  data: T;
}

interface Error {
  type: "error";
  message: string;
}

type UIState = Initial | Loading | Success | Error;

function renderUI(state: UIState): React.ReactNode {
  switch (state.type) {
    case "initial":
      return 
Veri yüklemek için düğmeye tıklayın.
;
    case "loading":
      return 
Yükleniyor...
;
    case "success":
      return 
{JSON.stringify(state.data, null, 2)}
;
    case "error":
      return 
Hata: {state.message}
;
    default:
      const _exhaustiveCheck: never = state;
      return _exhaustiveCheck;
  }
}

Bu örnek, ayrıştırılmış birleşimlerin bir UI bileşeninin farklı durumlarını etkili bir şekilde yönetmek için nasıl kullanılabileceğini ve UI'nin mevcut duruma göre doğru şekilde işlenmesini nasıl sağlayabileceğini göstermektedir. `renderUI` fonksiyonu her durumu uygun şekilde işleyerek UI'yi yönetmenin net ve tür güvenli bir yolunu sağlar.

Ayrıştırılmış Birleşimleri Kullanmak İçin En İyi Uygulamalar

TypeScript projelerinizde ayrıştırılmış birleşimleri etkili bir şekilde kullanmak için aşağıdaki en iyi uygulamaları göz önünde bulundurun:

Gelişmiş Teknikler

Koşullu Türler

Koşullu türler, daha da güçlü ve esnek durum makineleri oluşturmak için ayrıştırılmış birleşimlerle birleştirilebilir. Örneğin, mevcut duruma göre bir fonksiyon için farklı dönüş türleri tanımlamak için koşullu türler kullanabilirsiniz.


function getData(state: UIState): T | undefined {
  if (state.type === "success") {
    return state.data;
  }
  return undefined;
}

Bu fonksiyon basit bir `if` ifadesi kullanır, ancak her zaman belirli bir türün döndürülmesini sağlamak için koşullu türler kullanılarak daha sağlam hale getirilebilir.

Yardımcı Türler

TypeScript'in `Extract` ve `Omit` gibi yardımcı türleri, ayrıştırılmış birleşimlerle çalışırken yardımcı olabilir. `Extract`, bir koşula göre bir birleşim türünden belirli üyeleri çıkarmanıza olanak tanırken, `Omit`, bir türden özellikleri kaldırmanıza olanak tanır.


// UIState birleşiminden "success" durumunu çıkar
type SuccessState = Extract, { type: "success" }>;

// Error arayüzünden 'message' özelliğini çıkar
type ErrorWithoutMessage = Omit;

Farklı Sektörlerdeki Gerçek Dünya Örnekleri

Ayrıştırılmış birleşimlerin gücü çeşitli sektörlere ve uygulama alanlarına yayılır:

Sonuç

TypeScript ayrıştırılmış birleşimleri, durum makineleri oluşturmanın güçlü ve tür güvenli bir yolunu sağlar. Olası durumları ve geçişleri açıkça tanımlayarak, daha sağlam, bakımı kolay ve anlaşılır kod oluşturabilirsiniz. Tür güvenliği, kapsamlılık kontrolü ve geliştirilmiş kod tamamlama kombinasyonu, karmaşık durum yönetimi ile uğraşan herhangi bir TypeScript geliştiricisi için ayrıştırılmış birleşimleri paha biçilmez bir araç haline getirir. Bir sonraki projenizde ayrıştırılmış birleşimleri benimseyin ve tür güvenli durum yönetiminin faydalarını ilk elden deneyimleyin. E-ticaretten sağlık hizmetlerine, lojistikten eğitime kadar çeşitli örneklerle gösterdiğimiz gibi, ayrıştırılmış birleşimler yoluyla tür güvenli durum yönetimi ilkesi evrensel olarak uygulanabilir.

İster basit bir UI bileşeni, ister karmaşık bir kurumsal uygulama oluşturuyor olun, ayrıştırılmış birleşimler durumu daha etkili bir şekilde yönetmenize ve çalışma zamanı hataları riskini azaltmanıza yardımcı olabilir. Öyleyse, dalın ve TypeScript ile tür güvenli durum makineleri dünyasını keşfedin!

TypeScript Ayrıştırılmış Birleşimler: Tür Güvenli Durum Makineleri Oluşturma | MLOG